#########################################################
## WD já setado via abertura do projeto
setwd("~/R/explorar")
## zera todos os objetos
rm(list = ls()) 

library(dplyr) # data transformation
library(tibble) # column to rownames
library(devtools) # session info and parameters
library(formattable) # nicer truth tables
# para ler arquivos xls
library(readxl)
# para gravar arquivos xls (com limitações)
library(writexl)
# para gráficos
library(ggplot2)
library(readr)
library(dplyr)
# para processamento de datas
library(lubridate)


#######################################################
# instalação de pacotes QCA - feita em 05out2022
# do script do Patrick Mello
#install.packages("QCA")
#install.packages("SetMethods")
#install.packages("readxl")
library("QCA")
library("SetMethods")
# do script do Adrian na disciplina
library(dplyr) # data transformation
library(tibble) # column to rownames
library(devtools) # session info and parameters
library(formattable) # nicer truth tables
# para ler arquivos xls
library(readxl)
# para gravar arquivos xls (com limitações)
library(writexl)

#  não foi utilizado o pacote vdemdata, porque somente roda com
#   uma versão anterior do R (4.2.2). A manipulação dos dados V-Dem
#   foi feita diretamente
#######################################################3

#  soluções de emergência
# se rodar em outro ambiente: usar comando setwd
#  se der pau na leitura direta do xls, converter arquivos de 
#  entrada excel em csv e usar no estilo:
#                  modelo = read.csv("Polity V.csv", header = TRUE, sep = ";")


#################################################################
########################### funções pré-programadas
#################################################################
#### nome.funcao <- function(parm.funcao)
####   {  #begin function
#### comandos da funcao  
#### return (resultado.funcao) 
####  fim da função
####   }  #endfunction

###### compara duas linhas da matriz de casos; se em qualquer das condições causais
######  o valor em uma linha for superior a 0,5 e o outro inferior a 0,5, ou vice-versa,
###### retorna TRUE; caso contrário, retorna FALSE
compara.condicoes.fuzzy <- function(parm.linha.anterior, parm.linha.atual)
{  #begin function
   mudou.linha <- FALSE
   
   ano.anterior <- as.numeric(substr(rownames(parm.linha.anterior), 4, 7))
   ano.atual <- as.numeric(substr(rownames(parm.linha.atual), 4, 7))
   #  se mudou a presidencia
   
   if ( 
     (parm.linha.anterior$PRESIDENCY != parm.linha.atual$PRESIDENCY) |
        ( (parm.linha.anterior$PRESIDENCY == parm.linha.atual$PRESIDENCY) &
          (ano.atual - ano.anterior > 1) )
         )
   {mudou.linha <- TRUE}
   
   # se mudaram condicoes causais durante a presidencia
   for (i in (4:(ncol(parm.linha.anterior) - 1)))
   {
     if ( 
       ( (parm.linha.anterior [i] > 0.5 ) & (parm.linha.atual [i] < 0.5 )) |
          ( (parm.linha.anterior [i] < 0.5 ) & (parm.linha.atual [i] > 0.5 )) 
       
       )
     {
      mudou.linha <- TRUE 
     }
      }
return (mudou.linha) 
}  #endfunction  

###### segmenta os mandatos em função de mudanças nas condições causais (de >0,5 a < 0,5
###### ou vice-versa). Gera duas colunas adicionais:o segmento do mandato,  e o número de
######  anos que acumula a cada ano

segmenta.mandatos <- function(parm.matriz)
{  #begin function
  
#  aux.recupera.ano <- substr (rownames(parm.ano.pais) [i], 4,7)  
  
  eh.primeiro.registro <- TRUE
  linha.anterior <- parm.matriz [1,]
  aux.cont.anos.mandato <- 1
  aux.segmento.mandato <- 1
  
  for ( i in 1:nrow (parm.matriz))
  {
    linha.atual <- parm.matriz [i,]
    mudou.linha <- compara.condicoes.fuzzy (linha.anterior, linha.atual)
    
    if (mudou.linha)
    {
      aux.cont.anos.mandato <- 1
      if (linha.atual$PRESIDENCY != linha.anterior$PRESIDENCY)
      {aux.segmento.mandato <- 1}
      else 
      {aux.segmento.mandato <- aux.segmento.mandato + 1}
      # end-if-else
      
      linha.atual$PRESIDENCY_NUM_YEARS  <- aux.cont.anos.mandato
      linha.atual$PRESIDENCY_SEGMENT <- aux.segmento.mandato
    }
    else
    {
      
      aux.cont.anos.mandato <- aux.cont.anos.mandato + 1
      
      if (eh.primeiro.registro)
      {
        aux.segmento.mandato <- 1
        aux.cont.anos.mandato <- 1
        eh.primeiro.registro <- FALSE
      }
      
      linha.atual$PRESIDENCY_NUM_YEARS  <- aux.cont.anos.mandato
      linha.atual$PRESIDENCY_SEGMENT  <- aux.segmento.mandato
    } #end-else
    # end if-else
    linha.anterior <- parm.matriz [i,]
    parm.matriz [i,] <- linha.atual
  } #end-for
  
  return (parm.matriz)
}  #endfunction  


#####################
###  recalcula outcome a partir da média dos anos do mandato
###  
gera.outcome.fuzzy <- function(parm.mandato, parm.ano.pais, 
                               parm.GDP, parm.inequality,
                               eh.resultado.lagged)
{  #begin function

  #### inicializa acumuladores
  acm.GDP.pais <- 0
  acm.GDP.LatAm <- 0
  acm.inequality.pais <- 0
  acm.inequality.LatAm <- 0
  
  for (i in 1:nrow(parm.ano.pais))  # soma valores de GDP e inequality por mandato
  {
    if (  (parm.ano.pais$PRESIDENCY [i]  == parm.mandato$PRESIDENCY) &
          (parm.ano.pais$PRESIDENCY_SEGMENT [i] == substr(parm.mandato$PRESIDENCY_SEGMENT, 1,1) ) )
    {
      aux.recupera.ano <- substr (rownames(parm.ano.pais) [i], 4,7)
      if (eh.resultado.lagged)    # para o resultado lagged, os outcomes relevantes serão
                                  #  os do ano seguinte
        {aux.recupera.ano<- as.numeric (aux.recupera.ano) + 1}
      aux.recupera.pais <- substr (rownames(parm.ano.pais) [i], 1,2) 
      # vetor.variaveis.economicas: 4 posições: 1: GDP do país; 2: GDP médio LatAm;
      #                                     3: inequality do país; 4: inequality média LatAm
      vetor.variaveis.economicas <- recupera.variaveis.economicas (aux.recupera.pais, aux.recupera.ano,
                                                                   parm.GDP, parm.inequality)
      vetor.variaveis.economicas <- as.numeric(vetor.variaveis.economicas)

      acm.GDP.pais <- acm.GDP.pais + vetor.variaveis.economicas [1]
      acm.GDP.LatAm <- acm.GDP.LatAm + vetor.variaveis.economicas [2]
      acm.inequality.pais <- acm.inequality.pais + vetor.variaveis.economicas [3]
      acm.inequality.LatAm <- acm.inequality.LatAm + vetor.variaveis.economicas [4]
    }
  }
  
  # apura desempenho ao longo de todo o mandato comparado com a média latinoamericana
  #  (não é preciso tirar a média dos acumuladores, pois tanto o valor do país quanto o 
  #   latinoamericano seriam divididos pelo mesmo número de anos)
  if (acm.GDP.pais > acm.GDP.LatAm)
    {ind.performance.GDP <- 1}
  else
    {ind.performance.GDP <- 0}
  ## end if-else
  
  if (acm.inequality.pais > acm.inequality.LatAm)
  {ind.performance.inequality <- 1}
  else
  {ind.performance.inequality <- 0}
  ## end if-else
  
  if (ind.performance.GDP + ind.performance.inequality == 2)
  { novo.outcome <- 1 }
  else
  {
    if (ind.performance.GDP + ind.performance.inequality == 1)
    { novo.outcome <- 0.66 }
     else
     { novo.outcome <- 0 }   
  }
  return (novo.outcome) 
}  #endfunction


#####################
###  recupera valores primários de GDP e inequality
###  
recupera.variaveis.economicas <- function(parm.pais, parm.ano, 
                                          parm.GDP, parm.inequality)
{  #begin function
vetor.variaveis.economicas <- as.vector(c (0,0,0,0))

# carrega GDP
for (i in 1:nrow(parm.GDP))
{
  for (j in 2:18)
  {

      if ( (as.character(parm.GDP [i,1]) == as.character(parm.ano)) &
         (substr (colnames(parm.GDP) [j], 1, 2) == parm.pais) 
         ) 
    {
      vetor.variaveis.economicas [1] <- parm.GDP [i,j]
      vetor.variaveis.economicas [2] <- parm.GDP [i,19]
    }
  }
}

# carrega inequality
for (i in 3:43)  # a segunda linha é o ano de 1977, necessário
                                    # para o calculo da variação percentual mas não
                                    # inserido no time frame de análise. 
                                    # a linha final é colocada "ad hoc" como a relativa
                                    # ao ano de 2018 na planilha lida (a tentativa de
                                    # usar nrow(parm.inequality) gerou erros de leitura
{
  for (j in 21:37)
  {
    if (is.na(parm.inequality [i,j])) # trata o caso de algumas células de
                                     # desigualdade que têm valor NA
    { vetor.variaveis.economicas [3] <- NA
      vetor.variaveis.economicas [4] <- NA}
    else
    {
      
         if ( (as.character(parm.inequality [i,20]) == as.character(parm.ano)) &
         (parm.inequality [1,j] == parm.pais) 
        ) 
    {
      vetor.variaveis.economicas [3] <- parm.inequality [i,j]
      vetor.variaveis.economicas [4] <- parm.inequality [i,38]
    }
    }  # end-else (fim do tratamento de casos que não envolvem NA)  
  } # end-for (j)
} # end-for (i)

  return (vetor.variaveis.economicas) 
}  #endfunction


#####################
#  define valores fuzzy para o numero de anos do mandato
#  (4 ou mais = fuzzy 1; 3 = fuzzy 0,66; 2 = fuzzy 0,33; 1 = fuzzy 0)
#   dentro da lógica que mandatos com duração mais longa têm maiores possibilidades
#   de implementar suas políticas

converte.duracao.mandato.em.fuzzy <- function (aux.num.mandato)
{  #begin function
aux.num.mandato.em.fuzzy <- aux.num.mandato
aux.num.mandato.em.fuzzy <- NA

for (i in 1:nrow(aux.num.mandato))
{
    if (aux.num.mandato[i,1] > 3)   {aux.num.mandato.em.fuzzy [i] <-1}
    else
    { if (aux.num.mandato [i,1] == 3) {aux.num.mandato.em.fuzzy [i] <- 0.66}
      else 
      {
        if (aux.num.mandato [i,1] == 2) {aux.num.mandato.em.fuzzy [i] <- 0.33}
        else  {aux.num.mandato.em.fuzzy [i] <- 0}
       }
      }
  } #end for
  return (aux.num.mandato.em.fuzzy)  
} # end function


###########  PROCEDURE SECTION


#################################################################
###########################SETA PARAMETROS GERAIS
#################################################################


parm.inclui.non.party <- TRUE # incluindo ou não non-partisan,
parm.inclui.polarization <- TRUE  # incluindo ou não polarization
parm.inclui.single.party <- TRUE # incluindo ou não single party



#### carrega fontes (matriz de casos e planilha construída manualmente
#                     a partir de gabinetes e parlamentos)
planilha.original.mandatos <- as.data.frame(read.csv("Minority government identified by presidency.csv"))

matriz.ano.pais.lagged <- read.csv("matriz.de.casos.lagged.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
matriz.ano.pais.mesmo.ano <- read.csv("matriz.de.casos.mesmo.ano.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 

## seleciona as condições causais adicionais em função dos parâmetros gerais  
if (! parm.inclui.non.party)
  {matriz.ano.pais.lagged <- subset( matriz.ano.pais.lagged, select = -PARTISAN_CAB)
  matriz.ano.pais.mesmo.ano <- subset( matriz.ano.pais.mesmo.ano, select = -PARTISAN_CAB) }
if (! parm.inclui.polarization)
  {matriz.ano.pais.lagged <- subset( matriz.ano.pais.lagged, select = -POLARIZED)
matriz.ano.pais.mesmo.ano <- subset( matriz.ano.pais.mesmo.ano, select = -POLARIZED) }
  if (! parm.inclui.single.party)
  {matriz.ano.pais.lagged <- subset( matriz.ano.pais.lagged, select = -SINGLE_PARTY_CAB)
  matriz.ano.pais.mesmo.ano <- subset( matriz.ano.pais.mesmo.ano, select = -SINGLE_PARTY_CAB) }


###############
####  identifica cada ano-país com o seu respectivo mandato presidencial
##############

#### insere o mandato presidencial em cada linha ano-pais

matriz.ano.pais.mesmo.ano$PRESIDENCY <- NA
matriz.ano.pais.lagged$PRESIDENCY <- NA

for ( i in 1:nrow (matriz.ano.pais.mesmo.ano))
{
  for ( j in 1:nrow (planilha.original.mandatos))
  {
    aux.compara.ano.pais <- paste(as.character (planilha.original.mandatos$CTR [j]),
                                  " ",
                                 as.character (planilha.original.mandatos$YR [j]),
                                 sep="")

        if (aux.compara.ano.pais == row.names(matriz.ano.pais.mesmo.ano) [i])
    {
      matriz.ano.pais.mesmo.ano$PRESIDENCY [i] <- paste (planilha.original.mandatos$CTR [j], "-",
                                                        planilha.original.mandatos$PRESIDENCY [j], sep="") 
    }
  } # end-for
}  #  end-for


for ( i in 1:nrow (matriz.ano.pais.lagged))
{
  for ( j in 1:nrow (planilha.original.mandatos))
  {
    aux.compara.ano.pais <- paste(as.character (planilha.original.mandatos$CTR [j]),
                                  " ",
                                  as.character (planilha.original.mandatos$YR [j]),
                                  sep="")
    
    if (aux.compara.ano.pais == row.names(matriz.ano.pais.lagged) [i])
    {
      matriz.ano.pais.lagged$PRESIDENCY [i] <- paste (planilha.original.mandatos$CTR [j], "-",
                                                      planilha.original.mandatos$PRESIDENCY [j], sep="")  
    }
  } # end-for
}  #  end-for

###############
####  quebra os mandatos em segmentos em função de mudanças na composição
####  dos fatores de outcome (de >0,5 a < 0,5, ou vice-versa)
##############

matriz.ano.pais.mesmo.ano$PRESIDENCY_SEGMENT <- NA
matriz.ano.pais.lagged$PRESIDENCY_SEGMENT <- NA
matriz.ano.pais.mesmo.ano$PRESIDENCY_NUM_YEARS <- NA
matriz.ano.pais.lagged$PRESIDENCY_NUM_YEARS <- NA

# reorganiza ordem colunas para facilitar a leitura e o tratamento
matriz.ano.pais.mesmo.ano <- matriz.ano.pais.mesmo.ano %>% relocate (PRESIDENCY,
                              PRESIDENCY_SEGMENT,PRESIDENCY_NUM_YEARS, .before = POWERFUL_PRES)
matriz.ano.pais.mesmo.ano <- matriz.ano.pais.mesmo.ano %>% relocate (ACCOUNTABILITY,
                                                                     POLARIZED,
                                                                     .before = OUTCOME)

matriz.ano.pais.lagged <- matriz.ano.pais.lagged %>% relocate (PRESIDENCY,
                                                                     PRESIDENCY_SEGMENT,PRESIDENCY_NUM_YEARS, .before = POWERFUL_PRES)

matriz.ano.pais.lagged <- matriz.ano.pais.lagged %>% relocate (ACCOUNTABILITY,
                                                                     POLARIZED,
                                                                     .before = OUTCOME_LAGGED)
##################################

matriz.ano.pais.mesmo.ano <- segmenta.mandatos (matriz.ano.pais.mesmo.ano)

matriz.ano.pais.lagged <- segmenta.mandatos (matriz.ano.pais.lagged)

####  prepara variável para apontar o ano inicial e final de cada segmento
matriz.ano.pais.mesmo.ano$ANO.INICIAL <- as.numeric(substr (rownames(matriz.ano.pais.mesmo.ano), 4, 7))
matriz.ano.pais.mesmo.ano$ANO.FINAL <- matriz.ano.pais.mesmo.ano$ANO.INICIAL
matriz.ano.pais.lagged$ANO.INICIAL <-matriz.ano.pais.lagged$ANO.INICIAL <- as.numeric(substr (rownames(matriz.ano.pais.lagged), 4, 7))
matriz.ano.pais.lagged$ANO.FINAL <- matriz.ano.pais.lagged$ANO.INICIAL

###########
# agrupa os anos de cada segmento
#  (média dos valores das condições, soma do número de anos;
#   outcome é irrelevante, vai ser tratado no passo seguinte)
###########
matriz.mandato.mesmo.ano <- matriz.ano.pais.mesmo.ano %>%
  group_by(PRESIDENCY, PRESIDENCY_SEGMENT) %>%
  summarise(PRESIDENCY_NUM_YEARS = max(PRESIDENCY_NUM_YEARS), POWERFUL_PRES = mean(POWERFUL_PRES),
            RECONC_PARTY_GOAL = mean(RECONC_PARTY_GOAL), ABOVE_40_PCT = mean(ABOVE_40_PCT),
            PARTISAN_CAB = mean(PARTISAN_CAB), ACCOUNTABILITY = mean(ACCOUNTABILITY),
            POLARIZED = mean(POLARIZED), OUTCOME = mean(OUTCOME),
            ANO.INICIAL = min(ANO.INICIAL), ANO.FINAL = max(ANO.FINAL))

matriz.mandato.lagged <- matriz.ano.pais.lagged %>%
  group_by(PRESIDENCY, PRESIDENCY_SEGMENT) %>%
  summarise(PRESIDENCY_NUM_YEARS = max(PRESIDENCY_NUM_YEARS), POWERFUL_PRES = mean(POWERFUL_PRES),
            RECONC_PARTY_GOAL = mean(RECONC_PARTY_GOAL), ABOVE_40_PCT = mean(ABOVE_40_PCT),
            PARTISAN_CAB = mean(PARTISAN_CAB), ACCOUNTABILITY = mean(ACCOUNTABILITY),
            POLARIZED = mean(POLARIZED), OUTCOME_LAGGED = mean(OUTCOME_LAGGED),
            ANO.INICIAL = min(ANO.INICIAL), ANO.FINAL = max(ANO.FINAL))

## COMPLETA VARIÁVEL DE PRESIDENCY_SEGMENT COM ANO INICIAL E FINAL, 
##  E ELIMINA AS DUAS COLUNAS

matriz.mandato.mesmo.ano$PRESIDENCY_SEGMENT <- paste (matriz.mandato.mesmo.ano$PRESIDENCY_SEGMENT,
                                                      "-", matriz.mandato.mesmo.ano$ANO.INICIAL,
                                                      "-", matriz.mandato.mesmo.ano$ANO.FINAL,
                                                      sep="")

matriz.mandato.lagged$PRESIDENCY_SEGMENT <- paste (matriz.mandato.lagged$PRESIDENCY_SEGMENT,
                                                      "-", matriz.mandato.lagged$ANO.INICIAL,
                                                      "-", matriz.mandato.lagged$ANO.FINAL,
                                                      sep="")

matriz.mandato.mesmo.ano <- subset (matriz.mandato.mesmo.ano,
                                    select = - ANO.INICIAL)
matriz.mandato.mesmo.ano <- subset (matriz.mandato.mesmo.ano,
                                    select = - ANO.FINAL)




matriz.mandato.lagged <- subset (matriz.mandato.lagged,
                                    select = - ANO.INICIAL)
matriz.mandato.lagged <- subset (matriz.mandato.lagged,
                                    select = - ANO.FINAL)


############
#  redefine outcome: tira a média dos anos do período do mandato, 
#  compara com a média latino-americana no mesmo período, aplica a mesma
#   lógica para gerar indicador fuzzy unificado 
#
###########

### le os dados brutos de resultado econômico
recompoe.GDP <- read_xls("GDP v2.0.xls", sheet = "dados trabalhados")
recompoe.inequality <- read_xls("Inequality from household consumption v2.0.xls", sheet = "dados trabalhados")

recompoe.GDP <- as.data.frame(recompoe.GDP)
recompoe.inequality <- as.data.frame(recompoe.inequality)
aux.recompoe.outcome.mesmo.ano <- matriz.mandato.mesmo.ano %>%  
  select(PRESIDENCY, PRESIDENCY_SEGMENT, OUTCOME)
aux.recompoe.outcome.mesmo.ano <- as.data.frame(aux.recompoe.outcome.mesmo.ano)

aux.recompoe.outcome.lagged <- matriz.mandato.lagged %>%  
  select(PRESIDENCY, PRESIDENCY_SEGMENT, OUTCOME_LAGGED)
aux.recompoe.outcome.lagged <- as.data.frame(aux.recompoe.outcome.lagged)

eh.resultado.lagged <- FALSE
for ( i in (1:nrow(aux.recompoe.outcome.mesmo.ano)) )
{

   aux.recompoe.outcome.mesmo.ano$OUTCOME [i]  <- gera.outcome.fuzzy (aux.recompoe.outcome.mesmo.ano [i,],
                                                                     matriz.ano.pais.mesmo.ano,
                                                                     recompoe.GDP, recompoe.inequality,
                                                                     eh.resultado.lagged)
}

eh.resultado.lagged <- TRUE
for ( i in (1:nrow(aux.recompoe.outcome.lagged)) )
{
  aux.recompoe.outcome.lagged$OUTCOME_LAGGED  [i] <- gera.outcome.fuzzy (aux.recompoe.outcome.lagged [i,],
                                                                         matriz.ano.pais.lagged,
                                                                         recompoe.GDP, recompoe.inequality,
                                                                         eh.resultado.lagged)
}

matriz.mandato.mesmo.ano$OUTCOME <- aux.recompoe.outcome.mesmo.ano$OUTCOME
matriz.mandato.lagged$OUTCOME_LAGGED <- aux.recompoe.outcome.lagged$OUTCOME_LAGGED


############
#  define valores fuzzy para o numero de anos do mandato
#    lógica original descartada:
#   (4 ou mais = fuzzy 1; 3 = fuzzy 0,66; 2 = fuzzy 0,33; 1 = fuzzy 0)
#   dentro da lógica que mandatos com duração mais longa têm maiores possibilidades
#   de implementar suas políticas
#
#    lógica final prevalecente:
#   0, se o mandato é de 1 ano apenas (lame duck, mandato-tampão, "escorregão" de um majoritário)
#   1, nos demais casos
#   
###########
aux.num.mandato <- matriz.mandato.mesmo.ano$PRESIDENCY_NUM_YEARS
aux.num.mandato.em.fuzzy <- aux.num.mandato

# lógica anterior descartada:
#aux.num.mandato.em.fuzzy <- converte.duracao.mandato.em.fuzzy (aux.num.mandato)
#  lógica prevalecente:
for (i in 1:length(aux.num.mandato))
{
  if (aux.num.mandato [i] == 1)
    {aux.num.mandato.em.fuzzy [i] <- 0}
  else
    {aux.num.mandato.em.fuzzy [i] <- 1}
} #end-for
matriz.mandato.mesmo.ano$PRESIDENCY_NUM_YEARS <- aux.num.mandato.em.fuzzy
colnames(matriz.mandato.mesmo.ano) [3] <- "LONG_MANDATE"
matriz.mandato.mesmo.ano <- matriz.mandato.mesmo.ano %>% relocate (LONG_MANDATE,
                                                .before = OUTCOME)


aux.num.mandato <- matriz.mandato.lagged$PRESIDENCY_NUM_YEARS
aux.num.mandato.em.fuzzy <- aux.num.mandato

# lógica anterior descartada:
#aux.num.mandato.em.fuzzy <- converte.duracao.mandato.em.fuzzy (aux.num.mandato)
#  lógica prevalecente:
for (i in 1:length(aux.num.mandato))
{
  if (aux.num.mandato [i] == 1)
  {aux.num.mandato.em.fuzzy [i] <- 0}
  else
  {aux.num.mandato.em.fuzzy [i] <- 1}
} #end-for

matriz.mandato.lagged$PRESIDENCY_NUM_YEARS <- aux.num.mandato.em.fuzzy
colnames(matriz.mandato.lagged) [3] <- "LONG_MANDATE"
matriz.mandato.lagged <- matriz.mandato.lagged %>% relocate (LONG_MANDATE,
                                                                   .before = OUTCOME_LAGGED)


############
#  unifica as duas colunas identificadoras dos mandatos (presidência e segmento)
#  na forma de uma única coluna CASE_NAME
###########

for (i in 1:nrow(matriz.mandato.mesmo.ano))
{
  matriz.mandato.mesmo.ano$PRESIDENCY [i] <- paste (matriz.mandato.mesmo.ano$PRESIDENCY [i],
                                                 "-",
                                                 matriz.mandato.mesmo.ano$PRESIDENCY_SEGMENT [i],
                                                 sep="")
} # end for

matriz.mandato.mesmo.ano <- subset( matriz.mandato.mesmo.ano, select = -PRESIDENCY_SEGMENT)
colnames(matriz.mandato.mesmo.ano) [1] <- "CASE_NAME"


for (i in 1:nrow(matriz.mandato.lagged))
{
  matriz.mandato.lagged$PRESIDENCY [i] <- paste (matriz.mandato.lagged$PRESIDENCY [i],
                                                     "-",
                                                     matriz.mandato.lagged$PRESIDENCY_SEGMENT [i],
                                                     sep="")
} # end for

matriz.mandato.lagged <- subset( matriz.mandato.lagged, select = -PRESIDENCY_SEGMENT)
colnames(matriz.mandato.lagged) [1] <- "CASE_NAME"

####
######   imprime planilha excel por mandato
######
####
nome.arquivo.mandatos <- "Cases.by.mandate.xlsx"

data.e.hora.gravacao <- as.character (now())




mandatos.header <- as.data.frame(c("Data stratified by presidencies", "File saved at ",
                                    data.e.hora.gravacao))
colnames(mandatos.header) <- " "

mandatos.matriz <- list (Mandatos = mandatos.header,
                          Mandatos_matriz_YR = matriz.mandato.mesmo.ano, 
                          Mandatos_matriz_Lagged = matriz.mandato.lagged, 
                          Mandatos_ano.pais_YR = matriz.ano.pais.mesmo.ano,
                          Mandatos_ano.pais_Lagged = matriz.ano.pais.lagged)                      


write_xlsx(mandatos.matriz,
  path = nome.arquivo.mandatos,  
  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)

####
######   imprime matriz de casos csv por mandato para aplicação de QCA
######
####

nome.matriz.saida <- "matriz.de.casos.por.mandato.mesmo.ano.csv"
matriz.saida <- matriz.mandato.mesmo.ano

write.csv(matriz.saida, nome.matriz.saida, row.names=FALSE)



nome.matriz.saida <- "matriz.de.casos.por.mandato.lagged.csv"
matriz.saida <- matriz.mandato.lagged


write.csv(matriz.saida, nome.matriz.saida, row.names=FALSE)
